# nbi:hide_in
from __future__ import print_function
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
import nbinteract as nbi
from IPython.display import display
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.pyplot import figure, savefig
from pandas import DataFrame
from IPython.display import HTML, IFrame
import sys
sys.path.append('/home/nico/.local/lib/python3.8/site-packages')
from lcapy import Circuit
fig_sz_x = 10
fig_sz_y = 10
fig_dpi = 80 # dpi
fig_font_family = 'Ubuntu'
fig_font_size = 14
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
Vamos a usar las coordenadas $x$ (la abscisa) y la coordenada $y$ (la ordenada) del punto $P(x,y)$ para definir varias funciones trigonométricas. Por ejemplo, definimos a la función llamada seno asignando a cada número real t la coordenada $y$ del punto $P(x,y)$ determinado por $t$. Las funciones coseno, tangente, cosecante, secante y cotangente también se definen usando las coordenadas del punto $P(x,y)$.
Solo a modo informativo definiremos estas seis funciones pero nos concentraremos en la función seno y coseno , que son las que se utilizan en nuestra rama de estudio.
Estas definiciones se pueden aplicar a círculos no unitarios con una pequeña modificación. Anterior mente vimos que simplificamos la variable $r$ porque su valor era igual a $1$, si no lo es queda:
Veamos que representan gráficamente estas funciones en el círculo unitario.
.
.
.
Podemos ver que se nos formó un triángulo formado por el segmento en rojo $\overline{OA}$ , llamado cateto adyacente, el segmento en azul $\overline{AP}$ , llamado cateto opuesto, y el segmento en celeste $\overline{OP}$ , llamado hipotenusa, podemos definir las funciones trigonométricas como:
de esta manera definimos a las funciones trigonométricas en función del ángulo $\alpha$.
Esto es solo a modo informativo.
| Funciones | Dominio |
|---|---|
| $sen, cos$ | $\mathbb{R}$ |
| $tg, sec$ | $\mathbb{R} - \frac{\pi}{2}$+$n\pi$ para $n \in \mathbb{Z}$ |
| cotg, cosec | $\mathbb{R} -$ $n \pi$ para $n \in \mathbb{Z}$ |
Recordemos que el seno es el valor de la ordenada en el punto $P$, su altura, en el círculo unitario. por lo cual ¿Cuáles son los valores posibles del seno? Teniendo el círculo en mente podemos notar que la altura empieza en $0$ luego va creciendo hasta llegar a $1$. Continuando va decreciendo hasta llegar nuevamente en $0$. A partir de acá empieza a crecer de forma negativa hasta llegar a $-1$ y vuelve a a decrecer hasta llegar a $0$. Veamos esto gráficamente.
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
plt.style.use('seaborn-pastel')
N = 200
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
x = np.cos(t)
y = np.sin(t)
fig, ax = plt.subplots(figsize=(6, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
plt.title("Función senoidal" )
plt.plot(x,y)
ax = plt.axis([-1.1,1.1,-1.1,1.1])
redDot, = plt.plot([], [], 'ro')
text = plt.text(0,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')
line, = plt.plot(x,y,'r', lw=2)
def init():
line, = ax.plot(1,0, 'ro')
return line,
def animate(i):
plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
redDot.set_data(x[i],y[i])
text.set_text('y='+ str(np.round(y[i],3)))
#arrow.set_data(x[i],y[i])
line.set_data([x[i],x[i]], [0,y[i]])
return redDot, line, text, #arrow
# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N, interval=100, blit=True, repeat=True)
HTML(anim.to_jshtml())
Algo similar ocurre con la función coseno, con la diferencia que al ser el valor de la abscisa en el punto $P$, el largo del triángulo, esta parece empezar desplazada. Note que en este caso en ves de empezar con ancho $0$ empieza con un ancho de valor $1$. Sin embargo el recorrido es el mismo.
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
plt.style.use('seaborn-pastel')
N = 200
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
x = np.cos(t)
y = np.sin(t)
fig, ax = plt.subplots(figsize=(6, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
plt.title("Función coseno" )
plt.plot(x,y)
ax = plt.axis([-1.1,1.1,-1.1,1.1])
redDot, = plt.plot([], [], 'ro')
text = plt.text(0,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')
line, = plt.plot(x,y,'r', lw=2)
def init():
line, = ax.plot(1,0, 'ro')
return line,
def animate(i):
plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
redDot.set_data(x[i],y[i])
text.set_text('x='+ str(np.round(x[i],3)))
#arrow.set_data(x[i],y[i])
line.set_data([0,x[i]], [y[i],y[i]])
return redDot, line, text, #arrow
# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N, interval=100, blit=True, repeat=True)
HTML(anim.to_jshtml())
Como vemos de las animaciones llegamos a la siguiente conclusión para estas dos funciones:
| cuadrante | Función positiva | función negativa |
|---|---|---|
| I | todas | ninguna |
| II | seno | cosen |
| III | tg | coseno y seno |
| IV | coseno | seno |
Esto es un regla para memorizarlo, pero si recuerdan las definiciones se daran cuenta que esto es así por los signos de la variable $x$ e $y$ que usamos para definir las funciones.
Fue un camino largo pero llegamos a lo mas relevante para nosotros, conocer la gráfica de estas funciones. Esto nos va a permitir tener una mejor comprensión de su comportamiento.
Antes de graficarlas debemos notar algo, y es que dichas funciones se repiten cada vez que realizan una vuelta, es decir, al terminar una vuelta y comenzar una nueva se vuelven a repetir todos sus valores. A este tipo de funciones que se repiten se les llama periodicas y su periodo en este caso es $2\pi$ ya que recordemos que esa es la distancia que recorre el punto $P$ a lo largo de la circunferencia unitaria (esta distancia es el diámetro de la circunferencia). Por lo cual el valor del punto $P(x,y)$ determinado por el número real $t$ es el mismo que el determinado por $t+2\pi$.
Matemáticamente esto se escribe de la siguiente forma:
$n$ representa el número de vueltas.
De todas formas retomaremos esto mas adelante, no se desanimen si no lo terminan de entender ahora, al ver la gráfica les va a quedar mas claro.
Comencemos a graficar la función $senoidal$. Para ello recordemos que $sen(t)$ es la coordenada $y$ del $P(x,y)$ en la circunferencia unitaria determinado por el número real $t$. Recordemos de la animación que a medida que aumenta $t$ el valor del seno aumenta hasta llegar a $1$, luego disminuye hasta llegar a $-1$ y finalmente aumenta hasta llegar a $0$ y vuelve a comenzar.
Obtendremos la gráfica representando el valor de $y$ para cada valor de $t$ en un eje cartesiano y luego uniendo los puntos. Es el mismo método que usamos antes armando una tabla. La animación siguiente les muestra este proceso.
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
plt.style.use('seaborn-pastel')
N = 200
N1 = 25
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
t1 = np.linspace(0, 2*np.pi, N1)
x = np.cos(t) -1
y = np.sin(t)
x1 = np.cos(t1) -1
y1 = np.sin(t1)
figure
fig = plt.figure(figsize=(20, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2.1,2*np.pi+0.1), ylim=(-1.1,1.1))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.axvline(-1, color="grey")
plt.grid('on')
plt.xlabel('$t[rad]$',fontsize=14)
plt.title("$Función$ $senoidal$" )
ax.plot(x,y,label='$sen(t)$')
ax.legend(loc='upper right')
redDot, = ax.plot([], [], 'ro')
text = ax.text(-1,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')
line, = ax.plot(x1,y1,'r', lw=2)
def init():
line, = ax.plot(1,0, 'ro')
return line,
def animate(i):
plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
if i < N1:
ax.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
ax.set_xticklabels(["$0$", r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
redDot.set_data(x1[i],y1[i])
ax.plot(t1[i],y1[i],'ro',lw=2)
text.set_text('y='+ str(np.round(y1[i],3)))
#arrow.set_data(x[i],y[i])
line.set_data([x1[i],x1[i]], [0,y1[i]])
elif i == N1+1:
ax.plot(t,y,'b',lw=2,)
return redDot, line, text, #arrow
# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N1+8, interval=400, blit=True, repeat=True)
HTML(anim.to_jshtml())
Vemos que una parte de la señal es positiva y otra es negativa.
Vemos que tiene un valor máximo cuando $t=\frac{\pi}{2}$
Vemos que tiene un valor mínimo cuando $t=\frac{3\pi}{2}$
vemos que intersecta al eje $x$ (los ceros de la función) en tres lugares. En $x=0$, en $x=\pi$ y en $x=2\pi$
No se puede observar en este gráfico pero la señal se repite cada $t=t+2n\pi$ como mencionamos anteriormente.
Estos 5 puntos que mencionamos son muy relevantes, los estudiaremos en detalle en el siguiente capítulo.
De la misma forma vamos a graficar la función $cosenoidal$. Para ello recordemos que $cos(t)$ es la coordenada $x$ del $P(x,y)$ en la circunferencia unitaria determinado por el número real $t$. Recordemos de la animación que comienza con $x=1$ y medida que aumenta $t$ el valor del $cos$ disminuye hasta llegar a $0$, sigue disminuyendo hasta llegar a $-1$ y finalmente aumenta hasta llegar a $1$ y vuelve a comenzar.
Obtendremos la gráfica representando el valor de $x$ para cada valor de $t$ en un eje cartesiano y luego uniendo los puntos. Es similar al caso anterior, pero preste atención a la forma de la señal y compárela con la señal $senoidal$
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
plt.style.use('seaborn-pastel')
N = 200
N1 = 25
TWOPI = 2*np.pi
t = np.linspace(0, 2*np.pi, N)
t1 = np.linspace(0, 2*np.pi, N1)
x = np.cos(t) -1
y = np.sin(t)
x1 = np.cos(t1) -1
y1 = np.sin(t1)
figure
fig = plt.figure(figsize=(20, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2.1,2*np.pi+0.1), ylim=(-1.1,1.1))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.axvline(-1, color="grey")
plt.grid('on')
plt.xlabel('$t[rad]$',fontsize=14)
plt.title("$Función$ $cosenoidal$" )
ax.plot(x,y,label='$cos(t)$')
ax.legend(loc='upper center')
redDot, = ax.plot([], [], 'ro')
text = ax.text(-1,0,'',fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
horizontalalignment='center', verticalalignment='center')
#arrow = plt.arrow([], 0, 0, [], head_width=0.05, head_length=0.1, fc='r', ec='r')
line, = ax.plot(x1,y1,'r', lw=2)
def init():
line, = ax.plot(1,0, 'ro')
return line,
def animate(i):
plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
if i < N1:
ax.set_xticks([0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
ax.set_xticklabels(["$0$", r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
redDot.set_data(x1[i],y1[i])
ax.plot(t1[i],x1[i]+1,'ro',lw=2)
text.set_text('x='+ str(np.round(x1[i],3)))
#arrow.set_data(x[i],y[i])
line.set_data([-1,x1[i]], [y1[i],y1[i]])
elif i == N1+1:
ax.plot(t,x+1,'b',lw=2,)
return redDot, line, text, #arrow
# create animation using the animate() function
anim = FuncAnimation(fig, animate, frames=N1+8, interval=400, blit=True, repeat=True)
HTML(anim.to_jshtml())
Vemos que una parte de la señal es positiva y otra es negativa.
Vemos que tiene un valor máximo cuando $t=0$
Vemos que tiene un valor mínimo cuando $t=\pi$
vemos que intersecta al eje $x$ (los ceros de la función) en tres lugares. En $x=\frac{\pi}{2}$ y en $x=\frac{3\pi}{2}$
No se puede observar en este gráfico pero la señal se repite cada $t=t+2n\pi$ como mencionamos anteriormente.
Dejo esta inquietud planteada, lo retomaremos en el próximo capítulo. Puede revisar la propiedad de desplazamiento horizontal vista en la sección de Transformación de funciones. A continuación les dejo una animación que muestra esto.
# nbi:hide_in
%matplotlib inline
from matplotlib.animation import FuncAnimation
plt.rcParams.update({'font.size':fig_font_size})
plt.rcParams.update({'font.family':fig_font_family})
plt.style.use('seaborn-pastel')
fig = plt.figure(figsize=(8, 6), dpi= fig_dpi, facecolor='w', edgecolor='k')
ax = plt.axes(xlim=(-2*np.pi, 2*np.pi), ylim=(-2.2, 2.2))
plt.axhline(0, color="grey")
plt.axvline(0, color="grey")
plt.grid('on')
texto = ['$y=sin(x)$', '$y=sin(x+\pi/10)$', '$y=sin(x+\pi/5)$', '$y=(x+3\pi/10)$',
'$y=sin(x+2\pi/5)$', '$y=sin(x+\pi/2)$', '$y=cos(x)$']
line, = ax.plot([], [], lw=2)
c = np.linspace(.0,np.pi/2,6)
x = np.linspace(-2*np.pi, 2*np.pi, 1000)
text = ax.text(0,1.4,texto[0],fontsize=16,bbox=dict(facecolor='lightblue', alpha=1),
horizontalalignment='center', verticalalignment='bottom')
def init():
line.set_data([], [])
return line,
def animate(i):
plt.close() # por algun motivo que desconozco poniendolo aca borra el plot extra que aparece.
if i == 0:
#ax.plot(x, x**2, lw=2,color='red', label='$y=x²$')
#ax.legend(loc='upper center')
ax.set_xticks([ -2*np.pi, -1.5*np.pi, -np.pi, -.5*np.pi, 0., .5*np.pi, np.pi, 1.5*np.pi, 2*np.pi])
ax.set_xticklabels([r"$-2\pi$", r"$\frac{-3}{2}\pi$", r"$-\pi$", r"$\frac{-1}{2}\pi$", "$0$",
r"$\frac{1}{2}\pi$",r"$\pi$", r"$\frac{3}{2}\pi$", r"$2\pi$"])
ax.plot(x, np.sin(x), lw=2,color='red')
ax.text(0,1.8,texto[0],fontsize=16,bbox=dict(facecolor='red', alpha=0.5),
horizontalalignment='center', verticalalignment='bottom')
elif i<6:
y = np.sin(x+c[i])
line.set_data(x, y)
text.set_text(texto[i])
else:
text.set_text(texto[6])
return line,text,
anim = FuncAnimation(fig, animate, init_func=init, frames=9, interval=1000, blit=True)
HTML(anim.to_jshtml())
#anim.save('imagenes/sine_wave.gif', writer='imagemagick')
Finalizando les dejo una animación que muestro esto mismo de una forma similar, pero que les permite ver varios períodos de la señal. Deben seleccionar la función y mover el punto. Eso les va a mostrar como se mueve el punto en la gráfica de la función.
# nbi:hide_in
IFrame(src='https://phet.colorado.edu/sims/html/trig-tour/latest/trig-tour_en.html',width="800", height="600",scrolling="yes")
Copyright
The notebook is provided as Open Educational Resource. Feel free to use the notebook for your own educational purposes. The text is licensed under Creative Commons Attribution-NoComercial 4.0 Internacional, the code of the IPython examples under the MIT license. Please attribute the work as follows: Aplicaciones de electrónica Analógica by Nicolás Ferragamo.